1. Field of the Invention
This invention relates generally to the field of network-centric software development and more particularly relates to scripting user-interface components of a software application on an as-needed task basis.
2. Description of the Related Art
Like everything else, computer use has changed over the years. In the early days, large mainframe computers dominated the industry until the advent of the personal stand-alone computer and now many businesses and homes have at least one personal stand-alone computer, a PC. A new paradigm of computing, however, has emerged: network-centric computing or distributed computing in which at least two, but more likely many more computers, called clients and servers, are interconnected through a network wherein the logic and the software applications used by one client or server resides on another server. Thus, a server may provide the application or client program software, i.e., a software program typically written using a system programming language and used by an end user, and perhaps the databases for a number of other servers and clients over a network. For instance, a person entering data to schedule employees' work days may be using a scheduling client program or application. A person writing a paper may be using a word processing application. A person performing on-line banking is using a banking application.
In many instances and increasingly more so, the network connecting clients and servers is the world wide web. Software applications are written in a system programming language independent of the operating system of either the server or the client, such as JAVA™, to facilitate their use over the world wide web. Java is a trademark of Sun Microsystems. Java applications written on one computer are transferred over a network, such as the Internet, to any processing device having a Java virtual machine regardless of the hardware or software in the receiving machine.
Thus, this has created another fundamental change in the methodology of software developers in writing code for these applications. Rather than writing one massive self-contained application having thousands or millions of lines of code, software developers select and weave together smaller portions of code, called components, each associated with a particular function that can be reused across multiple applications. Components are standard software that can be pulled off a server and incorporated into new applications using a tool by software developers. For example, a calendar component may be used in several applications such as a scheduling application, a presentation application, a data base application to calculate employee's vacation and pay, etc.
Software developers started to use a scripting language to “glue” these components together into an application. Scripting languages and system programming languages are complementary and most major computing platforms provide both kinds of languages in which the reusable components are created with a system programming language and then glued together with a scripting language. Scripting languages, such as PERL, PYTHON, REXX, TCL, VISUAL BASIC and the UNIX shells, assume a collection or library of useful components written in other languages already exists. Visual Basic is a trademark of Microsoft Corporation; UNIX is a registered trademark licensed by The Open Group. Scripting is intended primarily for plugging together components, e.g., arranging user-interface controls on the screen or assembling filter programs into pipelines.
One highly desirable characteristic of a network-centric application is a zero-install client in which the software that executes the application on the client is not resident on the client computing device. Instead, the application is downloaded to the client from a server upon invocation or on-demand. There is tremendous cost benefit by not managing the application on many client devices and to download the application to a client when needed.
Downloading applications, however, require knowledge of the client device that hosts the user-interface portion of an application. Downloading large blocks of code from the server to the client so the user-interface portion would be a colorful display having moving pictures and sounds and other “bells and whistles” is prohibitive. Such software distribution would have to be planned to occur “off schedule” so as not to interfere with normal operation of the client and/or the server. Where once it was assumed that the client device was a PC and with its large memory capacity, now a myriad of simpler appliance-like client devices with less memory exist. A network computer or a thin client has a small fixed amount of memory, and voice response units (VRUs), terminals or web browsers, and even pervasive mobile devices, such as personal digital assistants, pagers, and cell-phones, have even less memory. Therefore, software developers developing applications such as on-line banking or on-line brokering must take into consideration the user-interface capacity of the client device. If the user-interface and the application software are downloaded into the client device, moreover, the latency of downloading has a serious effect on the effective performance of the application.
The problem of creating a high-performance environment for network centric applications in which the applications persist on the server, not on the client, is significant when business processes are encoded using system programming languages as hard-coded links between tasks, moreover, it is difficult for the application to adapt to changes in the business processes and there will also be large amounts of redundant code if the task-based components are to be used within multiple business processes. This is expensive to develop and maintain in large applications or large organizations. Most people are familiar with the model of executing JAVA applets within a web browser. The applets persist on the server and are downloaded and run on the client only when needed. However, the performance of applets with significant function is typically poor because of the large amount of executable code that must be downloaded and a web browser that executes JAVA applets will continue to accumulate byte code files as the applet executes. For that reason, JAVA applets have fallen out of favor.
There is thus a need for a solution that describes the task interfaces of the components and executes the task transitions on behalf of the component. From the point-of-view of the user-interface this mechanism should manage the navigation from one user-interface screen to the next.